Seleksi Fitur Scikit-learn: Menguasai Pengurangan Dimensi untuk Dataset Global

Dalam alam semesta data yang terus berkembang, banyaknya fitur dapat membanjiri bahkan model pembelajaran mesin yang paling canggih sekalipun. Fenomena ini, yang sering disebut sebagai "kutukan dimensi", dapat menyebabkan peningkatan biaya komputasi, mengurangi akurasi model, dan mengurangi kapasitas interpretasi. Untungnya, teknik seleksi fitur dan pengurangan dimensi menawarkan solusi yang ampuh. Scikit-learn, landasan ekosistem pembelajaran mesin Python, menyediakan serangkaian alat yang kaya untuk mengatasi tantangan ini secara efektif, menjadikannya sumber daya yang sangat diperlukan bagi ilmuwan data di seluruh dunia.

Panduan komprehensif ini akan menggali seluk-beluk kemampuan seleksi fitur Scikit-learn, dengan fokus pada pengurangan dimensi. Kami akan mengeksplorasi berbagai metodologi, prinsip-prinsip yang mendasarinya, implementasi praktis dengan contoh kode, dan pertimbangan untuk beragam dataset global. Tujuan kami adalah untuk membekali Anda, audiens global kami yang terdiri dari praktisi data yang bercita-cita tinggi dan berpengalaman, dengan pengetahuan untuk membuat keputusan yang tepat tentang seleksi fitur, yang mengarah pada model pembelajaran mesin yang lebih efisien, akurat, dan mudah ditafsirkan.

Memahami Pengurangan Dimensi

Sebelum kita menyelami alat khusus Scikit-learn, sangat penting untuk memahami konsep dasar pengurangan dimensi. Proses ini melibatkan transformasi data dari ruang berdimensi tinggi menjadi ruang berdimensi lebih rendah sambil mempertahankan sebanyak mungkin informasi penting. Manfaatnya sangat banyak:

• Pengurangan Overfitting: Lebih sedikit fitur berarti model yang lebih sederhana, kurang rentan terhadap pembelajaran noise dalam data pelatihan.
• Waktu Pelatihan Lebih Cepat: Model dengan lebih sedikit fitur dilatih secara signifikan lebih cepat.
• Peningkatan Interpretasi Model: Memahami hubungan antara lebih sedikit fitur lebih mudah.
• Pengurangan Ruang Penyimpanan: Dimensi yang lebih rendah membutuhkan lebih sedikit memori.
• Pengurangan Noise: Fitur yang tidak relevan atau berlebihan dapat dihilangkan, yang mengarah pada data yang lebih bersih.

Pengurangan dimensi secara luas dapat dikategorikan menjadi dua pendekatan utama:

1. Seleksi Fitur

Pendekatan ini melibatkan pemilihan subkumpulan fitur asli yang paling relevan dengan masalah yang dihadapi. Fitur asli dipertahankan, tetapi jumlahnya dikurangi. Anggap saja seperti mengidentifikasi bahan yang paling berdampak untuk resep dan membuang sisanya.

2. Ekstraksi Fitur

Pendekatan ini mengubah fitur asli menjadi kumpulan fitur baru yang lebih kecil. Fitur baru ini adalah kombinasi atau proyeksi dari yang asli, yang bertujuan untuk menangkap varians atau informasi yang paling signifikan dalam data. Ini mirip dengan membuat esensi yang disuling dari bahan-bahan asli.

Scikit-learn menawarkan alat yang ampuh untuk kedua pendekatan ini. Kami akan fokus pada teknik yang berkontribusi pada pengurangan dimensi, seringkali melalui seleksi atau ekstraksi fitur.

Metode Seleksi Fitur dalam Scikit-learn

Scikit-learn menyediakan beberapa cara untuk melakukan seleksi fitur. Ini secara luas dapat dikelompokkan ke dalam tiga kategori:

1. Metode Filter

Metode filter menilai relevansi fitur berdasarkan sifat intrinsiknya, terlepas dari model pembelajaran mesin tertentu. Mereka umumnya cepat dan hemat biaya komputasi, menjadikannya ideal untuk eksplorasi data awal atau saat berurusan dengan dataset yang sangat besar. Metrik umum termasuk korelasi, informasi mutual, dan uji statistik.

a) Seleksi Fitur Berbasis Korelasi

Fitur yang sangat berkorelasi dengan variabel target dianggap penting. Sebaliknya, fitur yang sangat berkorelasi satu sama lain (multikolinearitas) mungkin berlebihan dan dapat dipertimbangkan untuk dihapus. Modul feature_selection Scikit-learn menawarkan alat untuk membantu hal ini.

Contoh: Ambang Varians

Fitur dengan varians yang sangat rendah mungkin tidak memberikan banyak kekuatan diskriminatif. Kelas VarianceThreshold menghapus fitur yang variasinya tidak memenuhi ambang batas tertentu. Ini sangat berguna untuk fitur numerik.

            
from sklearn.feature_selection import VarianceThreshold
import numpy as np

X = [[0, 2, 0, 3], [0, 1, 4, 3], [0, 1, 1, 3]]
selector = VarianceThreshold(threshold=0.0)
selector.fit_transform(X)
# Output: array([[2, 0, 3], [1, 4, 3], [1, 1, 3]])

            

              
                Copy
              
            
          

Dalam contoh ini, fitur pertama (semua nol) memiliki varians nol dan dihapus. Ini adalah cara dasar tetapi efektif untuk membuang fitur konstan atau hampir konstan yang tidak menawarkan kekuatan prediktif.

Contoh: Korelasi dengan Target (menggunakan Pandas dan SciPy)

Meskipun Scikit-learn tidak memiliki fungsi tingkat tinggi langsung untuk korelasi dengan target di semua jenis fitur, ini adalah langkah praprosesan yang umum. Kita dapat menggunakan Pandas dan SciPy untuk ini.

            
import pandas as pd
import numpy as np
from scipy.stats import pearsonr

# Sample data
data = {
    'feature1': np.random.rand(100),
    'feature2': np.random.rand(100) * 2,
    'feature3': np.random.rand(100) - 1,
    'target': np.random.randint(0, 2, 100)
}
df = pd.DataFrame(data)

# Calculate Pearson correlation with the target
correlations = df.corr()['target'].drop('target')

# Select features with correlation above a certain threshold (e.g., 0.2)
selected_features = correlations[abs(correlations) > 0.2].index.tolist()
print(f"Features correlated with target: {selected_features}")

            

              
                Copy
              
            
          

Cuplikan ini menunjukkan cara mengidentifikasi fitur yang memiliki hubungan linier dengan variabel target. Untuk target biner, korelasi titik-biserial relevan, dan untuk target kategorikal, uji statistik lainnya lebih tepat.

b) Uji Statistik

Metode filter juga dapat menggunakan uji statistik untuk mengukur ketergantungan antara fitur dan variabel target. Ini sangat berguna saat berurusan dengan fitur kategorikal atau saat asumsi spesifik tentang distribusi data dapat dibuat.

Modul feature_selection Scikit-learn menyediakan:

• f_classif: Nilai F ANOVA antara label/fitur untuk tugas klasifikasi. Mengasumsikan fitur numerik dan target kategorikal.
• f_regression: Nilai F antara label/fitur untuk tugas regresi. Mengasumsikan fitur numerik dan target numerik.
• mutual_info_classif: Informasi mutual untuk variabel target diskrit. Dapat menangani hubungan non-linier.
• mutual_info_regression: Informasi mutual untuk variabel target kontinu.
• chi2: Statistik chi-kuadrat dari fitur non-negatif untuk tugas klasifikasi. Digunakan untuk fitur kategorikal.

Contoh: Menggunakan `f_classif` dan `SelectKBest`

SelectKBest adalah meta-transformer yang memungkinkan Anda memilih fitur berdasarkan fungsi penilaian yang dipilih (seperti f_classif).

            
from sklearn.datasets import load_iris
from sklearn.feature_selection import SelectKBest, f_classif

iris = load_iris()
X, y = iris.data, iris.target

# Select the top 2 features using f_classif
selector = SelectKBest(score_func=f_classif, k=2)
X_new = selector.fit_transform(X, y)

print(f"Original shape: {X.shape}")
print(f"Reduced shape: {X_new.shape}")

# To see which features were selected:
selected_indices = selector.get_support(indices=True)
print(f"Selected feature indices: {selected_indices}")
print(f"Selected feature names: {[iris.feature_names[i] for i in selected_indices]}")

            

              
                Copy
              
            
          

Contoh ini menunjukkan cara memilih 'k' fitur terbaik berdasarkan signifikansi statistik mereka untuk klasifikasi. Nilai F dalam f_classif pada dasarnya mengukur varians antara kelompok (kelas) relatif terhadap varians dalam kelompok. Nilai F yang lebih tinggi menunjukkan hubungan yang lebih kuat antara fitur dan target.

Pertimbangan Global: Saat bekerja dengan dataset dari berbagai wilayah (misalnya, data sensor dari berbagai iklim, data keuangan dari sistem ekonomi yang berbeda), sifat statistik fitur dapat sangat bervariasi. Memahami asumsi dari uji statistik ini (misalnya, normalitas untuk ANOVA) sangat penting, dan uji non-parametrik seperti informasi mutual mungkin lebih kuat dalam skenario yang beragam.

2. Metode Wrapper

Metode wrapper menggunakan model pembelajaran mesin tertentu untuk mengevaluasi kualitas subkumpulan fitur. Mereka 'membungkus' proses pelatihan model dalam strategi pencarian untuk menemukan kumpulan fitur yang optimal. Meskipun umumnya lebih akurat daripada metode filter, mereka secara komputasi jauh lebih mahal karena pelatihan model yang berulang.

a) Eliminasi Fitur Rekursif (RFE)

RFE bekerja dengan menghapus fitur secara rekursif. Dimulai dengan melatih model pada seluruh kumpulan fitur, lalu menghapus fitur yang paling tidak penting berdasarkan koefisien model atau kepentingan fitur. Proses ini diulangi hingga jumlah fitur yang diinginkan tercapai.

            
from sklearn.datasets import make_classification
from sklearn.feature_selection import RFE
from sklearn.linear_model import LogisticRegression

# Generate synthetic data
X, y = make_classification(n_samples=100, n_features=20, n_informative=10, n_redundant=5, random_state=42)

# Use a Logistic Regression model (can be any model that supports coef_ or feature_importances_)
estimator = LogisticRegression(solver='liblinear')

# Initialize RFE to select top 5 features
selector = RFE(estimator, n_features_to_select=5, step=1)
selector = selector.fit(X, y)

X_new = selector.transform(X)

print(f"Original shape: {X.shape}")
print(f"Reduced shape: {X_new.shape}")

# To see which features were selected:
selected_indices = selector.get_support(indices=True)
print(f"Selected feature indices: {selected_indices}")

            

              
                Copy
              
            
          

RFE sangat ampuh karena mempertimbangkan interaksi antara fitur sebagaimana dievaluasi oleh model yang dipilih. Parameter `step` mengontrol berapa banyak fitur yang dihapus pada setiap iterasi.

b) Seleksi Fitur Berurutan (SFS)

Meskipun bukan kelas langsung dalam feature_selection inti Scikit-learn, Seleksi Fitur Berurutan adalah pendekatan konseptual yang sering diimplementasikan menggunakan estimator Scikit-learn. Ini melibatkan Seleksi Maju (dimulai dengan kumpulan kosong dan menambahkan fitur satu per satu) atau Eliminasi Mundur (dimulai dengan semua fitur dan menghapusnya satu per satu). SequentialFeatureSelector Scikit-learn dalam sklearn.feature_selection mengimplementasikan ini.

            
from sklearn.feature_selection import SequentialFeatureSelector
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification

X, y = make_classification(n_samples=100, n_features=20, n_informative=10, n_redundant=5, random_state=42)

estimator = LogisticRegression(solver='liblinear')

# Forward selection: add features until desired number is reached
sfs_forward = SequentialFeatureSelector(
    estimator, n_features_to_select=10, direction='forward', cv=5)
sfs_forward.fit(X, y)
X_new_forward = sfs_forward.transform(X)

print(f"Forward Selection - Reduced shape: {X_new_forward.shape}")

# Backward selection: start with all features and remove
sfs_backward = SequentialFeatureSelector(
    estimator, n_features_to_select=10, direction='backward', cv=5)
sfs_backward.fit(X, y)
X_new_backward = sfs_backward.transform(X)

print(f"Backward Selection - Reduced shape: {X_new_backward.shape}")

            

              
                Copy
              
            
          

Parameter cv dalam SequentialFeatureSelector menandakan validasi silang, yang membantu membuat seleksi fitur lebih kuat dan kurang rentan terhadap overfitting data pelatihan. Ini adalah pertimbangan kritis saat menerapkan metode ini secara global, karena kualitas dan distribusi data dapat sangat bervariasi.

3. Metode Tertanam

Metode tertanam melakukan seleksi fitur sebagai bagian dari proses pelatihan model. Mereka memiliki keunggulan karena secara komputasi kurang mahal daripada metode wrapper sambil tetap mempertimbangkan interaksi fitur. Banyak model regularisasi termasuk dalam kategori ini.

a) Regularisasi L1 (Lasso)

Model seperti Lasso (Least Absolute Shrinkage and Selection Operator) dalam model linier menggunakan regularisasi L1. Teknik ini menambahkan penalti ke nilai absolut dari koefisien, yang dapat mendorong beberapa koefisien menjadi nol. Fitur dengan koefisien nol secara efektif dihapus.

            
from sklearn.linear_model import Lasso
from sklearn.datasets import make_regression

# Generate synthetic data
X, y = make_regression(n_samples=100, n_features=20, n_informative=10, random_state=42, noise=10)

# Lasso with alpha (regularization strength)
# A higher alpha leads to more regularization and potentially more zero coefficients
lasso = Lasso(alpha=0.1, random_state=42)
lasso.fit(X, y)

# Get the number of non-zero coefficients (selected features)
non_zero_features = np.sum(lasso.coef_ != 0)
print(f"Number of features selected by Lasso: {non_zero_features}")

# To get the actual selected features:
selected_features_mask = lasso.coef_ != 0
X_new = X[:, selected_features_mask]
print(f"Reduced shape: {X_new.shape}")

            

              
                Copy
              
            
          

LassoCV dapat digunakan untuk secara otomatis menemukan nilai alpha yang optimal melalui validasi silang.

b) Pentingnya Fitur Berbasis Pohon

Metode ensemble seperti RandomForestClassifier, GradientBoostingClassifier, dan ExtraTreesClassifier secara inheren menyediakan kepentingan fitur. Ini dihitung berdasarkan seberapa besar setiap fitur berkontribusi untuk mengurangi ketidakmurnian atau kesalahan di seluruh pohon dalam ensemble. Fitur dengan kepentingan rendah dapat dihapus.

            
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer

cancer = load_breast_cancer()
X, y = cancer.data, cancer.target

model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X, y)

# Get feature importances
importances = model.feature_importances_

# Sort features by importance
indices = np.argsort(importances)[::-1]

print("Feature ranking:")
for f in range(X.shape[1]):
    print(f"{f + 1}. feature {indices[f]} ({cancer.feature_names[indices[f]]}) - {importances[indices[f]]:.4f}")

# Select top N features (e.g., top 10)
N = 10
selected_features_mask = np.zeros(X.shape[1], dtype=bool)
selected_features_mask[indices[:N]] = True

X_new = X[:, selected_features_mask]
print(f"Reduced shape after selecting top {N} features: {X_new.shape}")

            

              
                Copy
              
            
          

Metode berbasis pohon sangat ampuh karena dapat menangkap hubungan non-linier dan interaksi fitur. Mereka banyak diterapkan di berbagai domain, mulai dari diagnosis medis (seperti dalam contoh) hingga deteksi penipuan keuangan di berbagai pasar.

Ekstraksi Fitur untuk Pengurangan Dimensi

Sementara seleksi fitur mempertahankan fitur asli, ekstraksi fitur membuat kumpulan fitur baru yang dikurangi. Ini sangat berguna ketika fitur asli sangat berkorelasi atau ketika Anda ingin memproyeksikan data ke ruang berdimensi lebih rendah yang menangkap varians paling banyak.

1. Analisis Komponen Utama (PCA)

PCA adalah teknik transformasi linier yang bertujuan untuk menemukan sekumpulan sumbu ortogonal (komponen utama) yang menangkap varians maksimum dalam data. Komponen utama pertama menangkap varians paling banyak, yang kedua menangkap yang paling banyak berikutnya (ortogonal ke yang pertama), dan seterusnya. Dengan hanya menyimpan 'k' komponen utama pertama, kita mencapai pengurangan dimensi.

Catatan Penting: PCA sensitif terhadap skala fitur. Sangat penting untuk menskalakan data Anda (misalnya, menggunakan StandardScaler) sebelum menerapkan PCA.

            
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.datasets import load_wine

wine = load_wine()
X, y = wine.data, wine.target

# Scale the data
X_scaled = StandardScaler().fit_transform(X)

# Initialize PCA to reduce to 2 components
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_scaled)

print(f"Original shape: {X.shape}")
print(f"Reduced shape after PCA: {X_pca.shape}")

# The explained variance ratio shows how much variance each component captures
print(f"Explained variance ratio: {pca.explained_variance_ratio_}")
print(f"Total explained variance: {np.sum(pca.explained_variance_ratio_):.4f}")

            

              
                Copy
              
            
          

PCA sangat bagus untuk memvisualisasikan data berdimensi tinggi dengan menguranginya menjadi 2 atau 3 dimensi. Ini adalah teknik fundamental dalam analisis data eksplorasi dan dapat secara signifikan mempercepat langkah-langkah pemodelan selanjutnya. Efektivitasnya diamati di berbagai domain seperti pemrosesan gambar dan genetika.

2. Analisis Diskriminan Linier (LDA)

Tidak seperti PCA, yang tidak diawasi dan bertujuan untuk memaksimalkan varians, LDA adalah teknik yang diawasi yang bertujuan untuk menemukan representasi berdimensi lebih rendah yang memaksimalkan keterpisahan antar kelas. Ini terutama digunakan untuk tugas klasifikasi.

Catatan Penting: LDA juga memerlukan fitur untuk diskalakan. Lebih lanjut, jumlah komponen dalam LDA dibatasi paling banyak n_classes - 1.

            
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_iris

iris = load_iris()
X, y = iris.data, iris.target

# Scale the data
X_scaled = StandardScaler().fit_transform(X)

# Initialize LDA. Number of components cannot exceed n_classes - 1 (which is 2 for Iris)
lda = LinearDiscriminantAnalysis(n_components=2)
X_lda = lda.fit_transform(X_scaled, y)

print(f"Original shape: {X.shape}")
print(f"Reduced shape after LDA: {X_lda.shape}")

# LDA also has explained_variance_ratio_ but it's class separability
print(f"Explained variance ratio (class separability): {lda.explained_variance_ratio_}")

            

              
                Copy
              
            
          

LDA sangat berguna ketika tujuannya adalah untuk membangun pengklasifikasi yang dapat membedakan dengan baik antara berbagai kategori dalam data Anda, yang merupakan tantangan umum dalam banyak aplikasi global seperti segmentasi pelanggan atau klasifikasi penyakit.

3. Embedding Tetangga Stokastik Ber-t-Terdistribusi (t-SNE)

t-SNE adalah teknik reduksi dimensi non-linier yang terutama digunakan untuk memvisualisasikan dataset berdimensi tinggi. Ia bekerja dengan memetakan titik data berdimensi tinggi ke ruang berdimensi rendah (biasanya 2D atau 3D) sedemikian rupa sehingga titik yang serupa dimodelkan oleh jarak yang serupa dalam ruang berdimensi rendah. Ini unggul dalam mengungkap struktur dan kluster lokal dalam data.

Catatan Penting: t-SNE mahal secara komputasi dan umumnya digunakan untuk visualisasi daripada sebagai langkah praprosesan untuk pelatihan model. Hasilnya juga dapat bervariasi dengan inisialisasi acak dan pengaturan parameter yang berbeda.

            
from sklearn.manifold import TSNE
from sklearn.datasets import load_digits
import matplotlib.pyplot as plt

digits = load_digits()
X, y = digits.data, digits.target

# For demonstration, we'll use a subset of the data as t-SNE can be slow
subset_indices = np.random.choice(len(X), 1000, replace=False)
X_subset = X[subset_indices]
y_subset = y[subset_indices]

# Initialize t-SNE with 2 components
# perplexity is related to the number of nearest neighbors (e.g., 30 is common)
# n_iter is the number of iterations for optimization
tsne = TSNE(n_components=2, perplexity=30, n_iter=300, random_state=42)
X_tsne = tsne.fit_transform(X_subset)

print(f"Original subset shape: {X_subset.shape}")
print(f"Reduced shape after t-SNE: {X_tsne.shape}")

# Plotting the results (optional, for visualization)
plt.figure(figsize=(10, 8))
scatter = plt.scatter(X_tsne[:, 0], X_tsne[:, 1], c=y_subset, cmap='viridis', alpha=0.7)
plt.title('t-SNE visualization of Digits dataset')
plt.xlabel('t-SNE component 1')
plt.ylabel('t-SNE component 2')
plt.legend(*scatter.legend_elements(), title='Classes')
plt.show()

            

              
                Copy
              
            
          

t-SNE sangat berharga untuk memahami struktur intrinsik data kompleks berdimensi tinggi yang ditemukan di bidang-bidang seperti genomik atau analisis jaringan sosial, menawarkan wawasan visual tentang pola yang mungkin tetap tersembunyi.

Memilih Teknik yang Tepat untuk Dataset Global

Memilih metode seleksi atau ekstraksi fitur yang tepat bukanlah keputusan yang cocok untuk semua. Beberapa faktor, terutama penting untuk dataset global, memengaruhi pilihan ini:

• Sifat Data: Apakah data Anda numerik, kategorikal, atau campuran? Apakah ada distribusi yang diketahui? Misalnya, chi2 cocok untuk fitur kategorikal non-negatif, sedangkan f_classif untuk fitur numerik dan target kategorikal.
• Jenis Model: Model linier mungkin mendapat manfaat dari regularisasi L1, sedangkan model berbasis pohon secara alami memberikan kepentingan.
• Sumber Daya Komputasi: Metode filter adalah yang tercepat, diikuti oleh metode tertanam, dan kemudian metode wrapper dan t-SNE.
• Persyaratan Interpretasi: Jika menjelaskan *mengapa* prediksi dibuat sangat penting, metode seleksi fitur yang mempertahankan fitur asli (seperti RFE atau L1) seringkali lebih disukai daripada metode ekstraksi fitur (seperti PCA) yang membuat komponen abstrak.
• Linearitas vs. Non-linearitas: PCA dan model linier mengasumsikan hubungan linier, sedangkan t-SNE dan metode berbasis pohon dapat menangkap pola non-linier.
• Diawasi vs. Tidak Diawasi: LDA diawasi (menggunakan variabel target), sedangkan PCA tidak diawasi.
• Skala dan Satuan: Untuk PCA dan LDA, penskalaan fitur sangat penting. Pertimbangkan perbedaan skala dalam data yang dikumpulkan dari berbagai wilayah global. Misalnya, nilai mata uang atau pembacaan sensor mungkin memiliki skala yang sangat berbeda di berbagai negara atau jenis sensor.
• Nuansa Budaya dan Regional: Saat bekerja dengan dataset yang melibatkan perilaku manusia, demografi, atau sentimen dari berbagai konteks budaya, interpretasi fitur dapat menjadi kompleks. Fitur yang sangat prediktif di satu wilayah mungkin tidak relevan atau bahkan menyesatkan di wilayah lain karena perbedaan norma sosial, kondisi ekonomi, atau metodologi pengumpulan data. Selalu pertimbangkan keahlian domain saat mengevaluasi kepentingan fitur di berbagai populasi.

Wawasan yang Dapat Ditindaklanjuti:

• Mulai Sederhana: Mulailah dengan metode filter (misalnya, Ambang Varians, uji statistik) untuk penilaian cepat dan untuk menghapus noise yang jelas.
• Iterasi dan Evaluasi: Bereksperimenlah dengan metode yang berbeda dan evaluasi dampaknya pada kinerja model Anda menggunakan metrik yang sesuai dan validasi silang.
• Visualisasikan: Gunakan teknik seperti PCA atau t-SNE untuk memvisualisasikan data Anda dalam dimensi yang lebih rendah, yang dapat mengungkapkan struktur yang mendasari dan menginformasikan strategi seleksi fitur Anda.
• Keahlian Domain adalah Kunci: Berkolaborasi dengan pakar domain untuk memahami arti dan relevansi fitur, terutama saat berurusan dengan data global yang kompleks.
• Pertimbangkan Pendekatan Ensemble: Menggabungkan beberapa teknik seleksi fitur terkadang dapat menghasilkan hasil yang lebih baik daripada hanya mengandalkan satu metode.

Pipeline Scikit-learn untuk Alur Kerja Terintegrasi

Objek Pipeline Scikit-learn sangat berguna untuk mengintegrasikan langkah-langkah praprosesan, termasuk seleksi/ekstraksi fitur, dengan pelatihan model. Ini memastikan bahwa seleksi fitur Anda dilakukan secara konsisten dalam setiap lipatan validasi silang, mencegah kebocoran data dan menghasilkan hasil yang lebih andal. Ini sangat penting saat membangun model yang akan digunakan di berbagai pasar global.

            
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.feature_selection import SelectKBest, f_classif
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.datasets import load_breast_cancer

bc = load_breast_cancer()
X, y = bc.data, bc.target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Create a pipeline that first scales, then selects features, then trains a classifier
pipe = Pipeline([
    ('scaler', StandardScaler()),
    ('selector', SelectKBest(score_func=f_classif, k=10)),
    ('classifier', LogisticRegression(solver='liblinear'))
])

# Train the pipeline
pipe.fit(X_train, y_train)

# Evaluate the pipeline using cross-validation
cv_scores = cross_val_score(pipe, X_train, y_train, cv=5)
print(f"Cross-validation scores: {cv_scores}")
print(f"Average CV score: {np.mean(cv_scores):.4f}")

# Make predictions on the test set
accuracy = pipe.score(X_test, y_test)
print(f"Test set accuracy: {accuracy:.4f}")

            

              
                Copy
              
            
          

Menggunakan pipeline memastikan bahwa seluruh proses—dari penskalaan hingga seleksi fitur hingga klasifikasi—diperlakukan sebagai entitas tunggal. Ini adalah praktik terbaik untuk pengembangan model yang kuat, terutama ketika model dimaksudkan untuk penerapan global di mana kinerja yang konsisten di berbagai distribusi data adalah kuncinya.

Kesimpulan

Pengurangan dimensi melalui seleksi dan ekstraksi fitur adalah langkah penting dalam membangun model pembelajaran mesin yang efisien, kuat, dan mudah ditafsirkan. Scikit-learn menyediakan toolkit komprehensif untuk mengatasi tantangan ini, memberdayakan ilmuwan data di seluruh dunia. Dengan memahami berbagai metodologi—filter, wrapper, metode tertanam, dan teknik ekstraksi fitur seperti PCA dan LDA—Anda dapat membuat keputusan yang tepat yang disesuaikan dengan dataset dan tujuan spesifik Anda.

Untuk audiens global kami, pertimbangannya melampaui hanya pilihan algoritma. Memahami asal data, potensi bias yang diperkenalkan oleh pengumpulan fitur di berbagai wilayah, dan kebutuhan interpretasi khusus dari pemangku kepentingan lokal sangat penting. Menggunakan alat seperti Pipeline Scikit-learn memastikan alur kerja yang terstruktur dan dapat direproduksi, yang sangat penting untuk menerapkan solusi AI yang andal di berbagai konteks internasional.

Saat Anda menavigasi kompleksitas ilmu data modern, menguasai kemampuan seleksi fitur Scikit-learn tidak diragukan lagi akan menjadi aset yang signifikan, yang memungkinkan Anda untuk membuka potensi penuh data Anda, apa pun asalnya.